home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / ucall19.lha / ucall / Source / ucall.c < prev    next >
C/C++ Source or Header  |  1995-08-25  |  44KB  |  1,469 lines
  1. #include "ucall.h"
  2.  
  3.  
  4. UBYTE  *read_buffer;
  5. UBYTE  *file_buffer;
  6. UBYTE  *last_line;
  7. UBYTE  *ct;
  8. UBYTE  *rcbuffer;
  9. UBYTE  *bf;
  10. UBYTE  *sendfilebuffer;
  11. UBYTE  *pb;
  12.  
  13. UBYTE  chr_buffer[MAX_BREAKCHARS];
  14. UBYTE  pattern_buffer[MAX_BREAKCHARS][BUFFER_SIZE_PATTERN];
  15.  
  16. struct Library *LocaleBase;
  17.  
  18. UBYTE  *uc_strings[] =
  19.         {
  20.          "(0)  UCall : Konfigfile %s nicht gefunden\n",
  21.          "(1)  USAGE : UCall Configfile Loginscript\n",
  22.          "(2)  UCall: %s ist kein UCall-Configfile !\n",
  23.          "(3)  UCall: Fehler im Configfile: %s\n",
  24.          "(4)  UCall: Konnte Metaxpr.library nicht öffnen !\n",
  25.          "(5)  UCall: Konnte timer.device nicht öffnen !\n",
  26.          "(6)  UCall: Konnte <%s> Unit %ld nicht öffnen !\n",
  27.          "(7)  UCall: Konnte MessagePort nicht öffnen !\n",
  28.          "(8)  UCall: Loginscript %s nicht gefunden\n",
  29.          " Programmabbruch durch Control-C\n",
  30.          "(10) UCALL: Sendfile %s konnte nocht geöffnet werden\n",
  31.          "(11) UCALL: Sendfile %s nicht gefunden\n",
  32.          "(12) UCALL: Abbruch wegen Speichermangel !\n",
  33.          "(13) SetFlag : Gültige Flags sind 8-31 !\n",
  34.          "(14) GOSUB-Sprungziel %s nicht gefunden\n",
  35.          "(15) RETURN ohne GOSUB gefunden !\n",
  36.          "(16) GOTO-Sprungziel %s nicht gefunden\n",
  37.          "(17) UCall : Anwahlversuch %s\n",
  38.          "(18) UCall : Besetzt !\n",
  39.          "(19) UCall : No Carrier  !\n",
  40.          "(20) UCall : Kein Freizeichen !\n",
  41.          "(21) **Warte noch %ld Sekunden **\r",
  42.          "(22) File nicht gefunden",
  43.          "(23) UCall-Setup: Nicht genügend Speicher !!\n",
  44.          " Programmabbruch durch Timeout-Error\n",
  45.          
  46.         };
  47.  
  48. UBYTE *monate[] =
  49.        {
  50.         "Januar","Februar","März","April","Mai","Juni","Juli","August","September",
  51.         "Oktober","November","Dezember",NULL,
  52.        };
  53.  
  54. UBYTE *tage[] =
  55.        {
  56.         "Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag",
  57.        };
  58.  
  59.  
  60. ULONG flags;
  61.  
  62. struct params usr_vars[] = 
  63.        {
  64.         "$linebuffer" ,V_LBSIZE,
  65.         "$ok"         ,V_OK,
  66.         "$error"      ,V_ERROR,
  67.         "$connect"    ,V_CONNECT,
  68.         "$nocarrier"  ,V_NOCARRIER,
  69.         "$nodialtone" ,V_NODIALTONE,
  70.         "$device"     ,V_DEVICE,
  71.         "$delayed"    ,V_DELAYED,
  72.         "$xprlib"     ,V_XPRLIB,
  73.         "$xpropts"    ,V_XPROPTS,
  74.         "$busy"       ,V_BUSY,
  75.         "$buffersize" ,V_BUFFER,
  76.         "$baud"       ,V_BAUD,
  77.         "$unit"       ,V_UNIT,
  78.         "$databits"   ,V_DATABITS,
  79.         "$stopbits"   ,V_STOPBITS,
  80.         "$parity"     ,V_PARITY,
  81.         "$line"       ,V_LINE,
  82.         "$date"       ,V_DATE,
  83.         "$time"       ,V_TIME,
  84.         "$config"     ,V_CONFIG,
  85.         "$script"     ,V_SCRIPT,
  86.         "$fileinfo"   ,V_FILEINFO,
  87.         "$handshake"  ,V_HANDSHAKE,
  88.         "$filename"   ,V_FILENAME,
  89.         "$filesize"   ,V_FILESIZE,
  90.         NULL,
  91.        };
  92.        
  93. struct user_param usr =
  94.        {
  95.         {"ucall.config"},
  96.         {"ucall.login"},
  97.         {"CONNECT"},
  98.         {"serial.device"},
  99.         {"NO CARRIER"},
  100.         {"BUSY"},
  101.         {"NO DIALTONE"},
  102.         {"DELAYED"},
  103.         {"ERROR"},
  104.         {"OK"},
  105.         {"xprzmodem.device"},
  106.         {" "},
  107.         {8},
  108.         {0},
  109.         {1},
  110.         {0},
  111.         {0},
  112.         {19200},
  113.         {8192},
  114.         {1024},
  115.        };
  116.        
  117. struct MsgPort  *serport;
  118. struct MsgPort  *TimerPort;
  119. struct IOExtSer *serial_req_read;
  120. struct IOExtSer *serial_req_write;
  121. struct IOExtSer *serial_req_cmd;
  122. struct Library  *TimerBase;
  123. struct Locale   *loc;
  124. struct Catalog  *cat;
  125. UWORD  serial_dever = TRUE;
  126. UWORD  timer_dev    = TRUE;
  127. UBYTE  global_flag;
  128. ULONG  global_timeout = 180;
  129. ULONG  global_repeat  = 120;
  130. struct timerequest *tr;
  131. struct List script;
  132. struct List return_stack;
  133. struct List vars;
  134. struct List extramem;
  135. ULONG global_timer = 0;
  136. struct Library *metaxprbase;
  137. BPTR   oldlock;
  138. BPTR   showlog;
  139. FILE  *protfile;
  140. UBYTE  ser_openflags = (SERF_7WIRE | SERF_SHARED);
  141. UBYTE  ser_flags     = (SERF_XDISABLED); 
  142. struct Node *script_node;
  143. struct Node *timeout_label;
  144. int readbytes;
  145. struct timeval     datum;
  146. struct ClockData   cd;
  147. UBYTE  *bfp;
  148.  
  149. struct Hook localedatehook =
  150.        {
  151.            {NULL, NULL},
  152.            (void *)locale_date_func,
  153.            NULL, NULL
  154.        };
  155.  
  156. struct params names[] = 
  157.        {
  158.         "DEVICE"     ,P_DEVICE,
  159.         "UNIT"       ,P_UNIT,
  160.         "BAUD"       ,P_BAUD,
  161.         "BUSY"       ,P_BUSY,
  162.         "NOCARRIER"  ,P_NOCARRIER,
  163.         "NODIALTONE" ,P_NODIALTONE,
  164.         "DELAYED"    ,P_DELAYED,
  165.         "ERROR"      ,P_ERROR,
  166.         "CONNECT"    ,P_CONNECT,
  167.         "XPRLIB"     ,P_XPRLIB,
  168.         "XPROPTS"    ,P_XPROPT,
  169.         "DATENBITS"  ,P_DATABITS,
  170.         "PARITY"     ,P_PARITY,
  171.         "STOPBITS"   ,P_STOPBITS,
  172.         "RTS/CTS"    ,P_RTS,
  173.         "XON/OFF"    ,P_XON,
  174.         "BUFFER"     ,P_BUFFER,
  175.         "OK"         ,P_OK,
  176.         NULL,0
  177.     };
  178.         
  179. struct params cmds[] =
  180.        {
  181.         "SENDFILE"   ,C_TEXTFILE,
  182.         "SETENV"     ,C_SETENV,
  183.         "GETENV"     ,C_GETENV,
  184.         "IFVAR"      ,C_IFVAR,  
  185.         "SETFLAG"    ,C_SETFLAG,
  186.         "CLEARFLAG"  ,C_CLEARFLAG,
  187.         "IFFLAG"     ,C_IFFLAG,   
  188.         "CONNECT"    ,C_WCONNECT,
  189.         "CRLF"       ,C_CRLF,
  190.         "SEND"       ,C_SEND,
  191.         "WAIT"       ,C_WAIT,
  192.         "MSG"        ,C_MSG,
  193.         "PUTFILE"    ,C_SENDFILE,
  194.         "GETFILE"    ,C_GETFILE,
  195.         ";"          ,C_COMMENT,  
  196.         "SHOWLOGIN"  ,C_SHLOG,
  197.         "TIMEOUT"    ,C_TIMEOUT,
  198.         "PAUSE"      ,C_REPEAT,
  199.         "SYSTEM"     ,C_SYSTEM,
  200.         "WORKDIR"    ,C_WORKDIR,
  201.         "GOTO"       ,C_GOTO,
  202.         LABEL_STRING ,C_LABEL,
  203.         "IF"         ,C_IF,
  204.         "END"        ,C_END,
  205.         "GOSUB"      ,C_GOSUB,
  206.         "RETURN"     ,C_RETURN,
  207.         "TIMEOUT_LABEL",C_TIMELABEL,
  208.         "PROTOCOL"   ,C_PROTOCOL,
  209.         "PROTMSG"    ,C_PROTMSG,
  210.         "SET"        ,C_SET,
  211.         "RESETLINE"  ,C_RESETLINE,
  212.         "LINEBUFFER" ,C_LBSIZE,
  213.         "DELAY"      ,C_DELAY,
  214.         NULL,0
  215.        };
  216.        
  217. UBYTE *zcversion = ZC_VERSION;
  218.  
  219. void __stdargs main(int argc, char *argv[])
  220. {
  221.  NewList(&script);
  222.  NewList(&return_stack);
  223.  NewList(&vars);
  224.  NewList(&extramem);
  225.  getlocale();
  226.  oldlock = Lock("",SHARED_LOCK);
  227.  Printf("\x1b[2m%s\x1b[0m\n",zcversion);
  228.  Printf("Freeware by Lunqual%%mab@wsb.freinet.de\n\n");
  229.  if(argc == 3)
  230.  {
  231.   strcpy(usr.cfgfile,argv[1]);
  232.   strcpy(usr.script,argv[2]);
  233.   if(rcbuffer = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  234.   {
  235.    if(readconfig(argv[1]))
  236.    {
  237.     if(ser_setup())
  238.     {
  239.      if(readscript(argv[2]))
  240.      {
  241.       makecall();
  242.      }
  243.     }
  244.     ser_cleanup(0);
  245.    }    
  246.   }
  247.  }
  248.  else  Printf(GETSTR(1));
  249.  releaselocale();
  250.  exit(0);
  251. }
  252.  
  253.  
  254.  
  255. int __regargs readconfig(UBYTE *filename)
  256. {
  257.  BOOL rc    = FALSE;
  258.  BOOL begin = FALSE;
  259.  FILE *file;
  260.  if(file = fopen(filename,"r"))
  261.  {
  262.   rc = TRUE;
  263.   while(fgets(rcbuffer,usr.lbsize,file))
  264.   {
  265.    if(IsZcConf(rcbuffer))
  266.    {
  267.     if(!begin)
  268.     {
  269.      begin = TRUE;
  270.     }
  271.     else break;
  272.    }
  273.    {
  274.     ULONG cl;
  275.     if(begin)
  276.     {
  277.      cl = checkline(rcbuffer);
  278.      if(cl)parseline(rcbuffer,cl);
  279.     }
  280.    }
  281.   }
  282.   if((rc)&&(!begin)){Printf(GETSTR(3),filename);rc = FALSE;}
  283.   fclose(file);
  284.  }
  285.  else Printf(GETSTR(0),filename);
  286.  return rc;
  287. }
  288.  
  289. void __regargs parseline(UBYTE *buffer,ULONG what)
  290. {
  291.  UBYTE *p = buffer;
  292.  if(what)
  293.  {
  294.   BOOL found = FALSE;
  295.   while(*p)
  296.   {
  297.    if(*p == '=')
  298.    {
  299.     p++;
  300.     found = TRUE;
  301.     break;
  302.    }
  303.    p++;
  304.   }  
  305.   if(found)
  306.   {
  307.    switch(what)
  308.    {
  309.     case P_BUFFER    : {
  310.                         ULONG s;
  311.                         if(isdigit(*p))
  312.                         {
  313.                          s = atol(p);
  314.                          if(s >= 1024)usr.bufsize = s;
  315.                         }
  316.                        }
  317.                        break;
  318.     case P_CONNECT   : *(buffer + strlen(buffer) - 1) = 0;
  319.                        strcpy(usr.connect,p);
  320.                        break;
  321.     case P_BUSY      : *(buffer + strlen(buffer) - 1) = 0;
  322.                        strcpy(usr.busy,p);
  323.                        break;
  324.     case P_OK        : *(buffer + strlen(buffer) - 1) = 0;
  325.                        strcpy(usr.ok,p);
  326.                        break;
  327.     case P_NOCARRIER : *(buffer + strlen(buffer) - 1) = 0;
  328.                        strcpy(usr.nocarrier,p);
  329.                        break;
  330.     case P_NODIALTONE: *(buffer + strlen(buffer) - 1) = 0;
  331.                        strcpy(usr.nodialtone,p);
  332.                        break;
  333.     case P_DEVICE    : *(buffer + strlen(buffer) - 1) = 0;
  334.                        strcpy(usr.device,p);
  335.                        break;
  336.     case P_ERROR    : *(buffer + strlen(buffer) - 1) = 0;
  337.                        strcpy(usr.error,p);
  338.                        break;
  339.     case P_UNIT      : if(isdigit(*p))usr.unit = atol(p);
  340.                        break;
  341.     case P_DELAYED   : *(buffer + strlen(buffer) - 1) = 0;
  342.                        strcpy(usr.delayed,p);
  343.     case P_XPRLIB    : *(buffer + strlen(buffer) - 1) = 0;
  344.                        strcpy(usr.xprlib,p);
  345.                        break;
  346.     case P_XPROPT    : *(buffer + strlen(buffer) - 1) = 0;
  347.                        strcpy(usr.xpropt,p);     
  348.                        break;
  349.     case P_BAUD      : if(isdigit(*p))usr.baud = atol(p);
  350.                        break;
  351.     case P_DATABITS  : if(isdigit(*p))
  352.                        {
  353.                         usr.data = (UBYTE)atol(p);
  354.                         if((usr.data < 7 ) || (usr.data > 8))usr.data = 8;
  355.                        }
  356.                        break;
  357.     case P_STOPBITS  : if(isdigit(*p))
  358.                        {
  359.                         usr.stop = (UBYTE)atol(p);
  360.                         if((usr.stop < 0 ) || (usr.stop > 2))usr.data = 1;
  361.                        }
  362.                        break;
  363.     case P_RTS       : ser_openflags = (SERF_7WIRE | SERF_SHARED);
  364.                        ser_flags     = (SERF_XDISABLED);
  365.                        usr.handshake = 0;
  366.                        break;
  367.     case P_XON       : ser_openflags = (SERF_SHARED);
  368.                        ser_flags     = (0);
  369.                        usr.handshake = 1;
  370.                        break;
  371.     case P_PARITY    : if(!strnicmp(p,"odd",strlen("odd")))
  372.                        {
  373.                         ser_flags |= (SERF_PARTY_ODD | SERF_PARTY_ON);
  374.                         usr.parity = 2;   
  375.                        }
  376.                        else if(!strnicmp(p,"even",strlen("even")))
  377.                        {
  378.                         ser_flags |= (SERF_PARTY_ON);
  379.                         usr.parity = 1;
  380.                        }
  381.                        break;
  382.    }
  383.   }
  384.   else Printf(GETSTR(3),buffer);  
  385.  }
  386. }
  387.  
  388. ULONG __regargs checkline(UBYTE *buffer)
  389. {
  390.  ULONG i;
  391.  ULONG rc = 0;
  392.  if(*buffer > ' ')
  393.  {
  394.   for(i=0;names[i].text;i++)
  395.   {
  396.    if(!strnicmp(buffer,names[i].text,strlen(names[i].text)))
  397.    {
  398.     rc = names[i].n;
  399.     break;
  400.    }
  401.   }
  402.  }
  403.  return rc;
  404. }
  405.  
  406. int  __regargs IsZcConf(UBYTE *buffer)
  407. {
  408.  return (!strnicmp(buffer,UCALL_CONFIG,strlen(UCALL_CONFIG))) ? TRUE  : FALSE;
  409. }
  410.  
  411. int ser_setup()
  412. {
  413.  int rc= FALSE;
  414.  if(serport = CreateMsgPort())
  415.  {
  416.   if(serial_req_read = (struct IOExtSer *)CreateExtIO( serport, sizeof( struct IOExtSer )))
  417.   {
  418.    if(serial_req_write = (struct IOExtSer *)CreateExtIO( serport, sizeof( struct IOExtSer )))
  419.    {
  420.     if(serial_req_cmd = (struct IOExtSer *)CreateExtIO( serport, sizeof( struct IOExtSer )))
  421.     {
  422.      serial_req_read->io_SerFlags= ser_openflags;
  423.      if(!(serial_dever = OpenDevice( usr.device, usr.unit, serial_req_read,0)))
  424.      {
  425.       CopyMem(serial_req_read,serial_req_write,sizeof(struct IOExtSer));
  426.       CopyMem(serial_req_read,serial_req_cmd,sizeof(struct IOExtSer));
  427.       {
  428.        serial_req_cmd->io_RBufLen  = usr.bufsize;
  429.        serial_req_cmd->io_Baud     = usr.baud;
  430.        serial_req_cmd->io_BrkTime  = BREAK_TIME;  
  431.        serial_req_cmd->io_ReadLen  = usr.data;
  432.        serial_req_cmd->io_WriteLen = usr.data;
  433.        serial_req_cmd->io_StopBits = usr.stop;
  434.        serial_req_cmd->io_SerFlags = ser_flags;
  435.        serial_req_cmd->io_ExtFlags = ADDITIONAL_FLAGS;
  436.        serial_req_cmd->IOSer.io_Command = SDCMD_SETPARAMS;  
  437.        DoIO( serial_req_cmd );
  438.        {
  439.         if(opentimerdevice())
  440.         {
  441.          TimerBase = (struct Library *)tr->tr_node.io_Device;
  442.          if(metaxprbase = OpenLibrary("metaxpr.library",2))
  443.          {
  444.           if(getbuffers())
  445.           {
  446.            rc = TRUE;
  447.           }
  448.          }
  449.          else Printf(GETSTR(4));
  450.         }
  451.         else Printf(GETSTR(5));
  452.        }
  453.       }
  454.      }
  455.      else Printf(GETSTR(6),usr.device,usr.unit);
  456.     }
  457.    }
  458.   }
  459.  }
  460.  else Printf(GETSTR(7));
  461.  return rc;
  462. }
  463.  
  464. int opentimerdevice()
  465. {
  466.  if(TimerPort = CreateMsgPort())
  467.  {
  468.   if(tr = (struct timerequest *)CreateExtIO(TimerPort,sizeof(struct timerequest)))
  469.   {
  470.    if(timer_dev = OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)tr,0))
  471.    {
  472.     DeleteExtIO(tr);
  473.     return FALSE;
  474.    }
  475.   }
  476.  } 
  477.  return TRUE;
  478. }
  479.  
  480. void closetimerdevice()
  481. {
  482.  if((tr) && (!CheckIO(tr)))
  483.  {
  484.   AbortIO(tr);
  485.   WaitIO(tr);
  486.  }
  487.  if(!timer_dev)CloseDevice(tr);
  488.  if(tr)DeleteExtIO(tr);
  489.  if(TimerPort)DeleteMsgPort(TimerPort);
  490. }
  491.  
  492.  
  493.  
  494. void __regargs ser_cleanup(ULONG rc)
  495. {
  496.  struct Node *scr;
  497.  if( serial_req_read && (!CheckIO(serial_req_read)))
  498.  {
  499.   AbortIO(serial_req_read);
  500.   WaitIO(serial_req_read);
  501.  }
  502.  if( serial_req_write && (!CheckIO(serial_req_write)))
  503.  {
  504.   AbortIO(serial_req_write);
  505.   WaitIO(serial_req_write);
  506.  }
  507.  if( serial_req_cmd && (!CheckIO(serial_req_cmd)))
  508.  {
  509.   AbortIO(serial_req_cmd);
  510.   WaitIO(serial_req_cmd);
  511.  }
  512.  serial_req_cmd->IOSer.io_Command = CMD_RESET;  
  513.  DoIO( serial_req_cmd );
  514.  WaitIO(serial_req_cmd);
  515.  if( !serial_dever )CloseDevice( serial_req_read );
  516.  if(serial_req_read) DeleteExtIO( serial_req_read );
  517.  if(serial_req_write) DeleteExtIO( serial_req_write );
  518.  if(serial_req_cmd) DeleteExtIO( serial_req_cmd );
  519.  if( serport )DeletePort(serport);
  520.  closetimerdevice();
  521.  while(scr = RemHead(&return_stack))
  522.  {
  523.   FreeVec(scr);
  524.  }
  525.  freebuffers();
  526.  if(rc == CLEANUP_RESTART)
  527.  {
  528.   Delay(100);
  529.   if(ser_setup())return;
  530.  }
  531.  while(scr = RemHead(&script))
  532.  {
  533.   if(scr->ln_Name)FreeVec(scr->ln_Name);
  534.   FreeVec(scr);
  535.  }
  536.  {
  537.   struct var_node *v;
  538.   while(v = (struct var_node *)RemHead(&vars))
  539.   {
  540.    if(v->node.ln_Name)FreeVec(v->node.ln_Name);
  541.    if(v->text)FreeVec(v->text);
  542.    FreeVec(v);
  543.   }
  544.  }
  545.  while(scr = RemHead(&extramem))
  546.  {
  547.   if(scr->ln_Name)FreeVec(scr->ln_Name);
  548.   FreeVec(scr);
  549.  }
  550.  if(metaxprbase)CloseLibrary(metaxprbase);
  551.  if(oldlock)
  552.  {
  553.   BPTR newlock;
  554.   if(newlock = CurrentDir(oldlock))UnLock(newlock);
  555.  }
  556.  if(sendfilebuffer)FreeVec(sendfilebuffer);
  557.  if(showlog)Close(showlog);
  558.  if(protfile)fclose(protfile);
  559.  if(rcbuffer)FreeVec(rcbuffer);
  560.  releaselocale();
  561.  exit(rc);
  562. }
  563.  
  564.  
  565. int __regargs read_line(UBYTE *buffer,UBYTE *chrs,UBYTE n)
  566. {
  567.  int rc = 1;
  568.  UBYTE i;
  569.  while(1)
  570.  {
  571.   int r;
  572.   r = SerRead(serial_req_read,buffer + readbytes,1);
  573.   if(!r)return 0;
  574.   for(i = 0; i < n;i++)
  575.   {
  576.    if (*(buffer + readbytes) == *(chrs + i))
  577.    {
  578.     readbytes++;
  579.     return 3;
  580.    }
  581.   }
  582.   if(*(buffer + readbytes) == '\n')
  583.   {
  584.    readbytes = 0;
  585.    memset(buffer,0,usr.lbsize);
  586.    return 2;
  587.   }
  588.   readbytes++;if(readbytes >= usr.lbsize)readbytes = 0;
  589.  }
  590.  return rc;
  591. }
  592.  
  593. int __regargs readscript(UBYTE *filename)
  594. {
  595.  int rc = TRUE;
  596.  FILE *scr;
  597.  struct Node *s;
  598.  memset(read_buffer,0,usr.lbsize);
  599.  if(scr = fopen(filename,"r"))
  600.  {
  601.   while(fgets(read_buffer,usr.lbsize,scr))
  602.   {
  603.    if((*read_buffer) && (*(read_buffer + strlen(read_buffer) - 1) == '\n'))*(read_buffer + strlen(read_buffer) - 1) = 0;
  604.    if(*read_buffer)
  605.    {
  606.     if(s = (struct Node *)AllocVec(sizeof(struct Node),MEMF_ANY | MEMF_CLEAR))
  607.     {
  608.      if(s->ln_Name = AllocVec(strlen(read_buffer) + 10,MEMF_ANY | MEMF_CLEAR))
  609.      {
  610.       if(!strnicmp(read_buffer,LABEL_STRING,strlen(LABEL_STRING)))
  611.       {
  612.        UBYTE *p = read_buffer;
  613.        if(*(read_buffer + strlen(read_buffer) - 1) == '\n')*(read_buffer + strlen(read_buffer) - 1) = 0;
  614.        strcpy(s->ln_Name,LABELINTRO);
  615.        while((*p) && (*p != ' ') && (*p != '\n'))p++;
  616.        p = stpblk(p);
  617.        strcat(s->ln_Name,p);
  618.       }
  619.       else strcpy(s->ln_Name,read_buffer);
  620.       AddTail(&script,s);
  621.      }
  622.      else 
  623.      {
  624.       rc = FALSE;
  625.       break;
  626.      }
  627.     } 
  628.     else
  629.     { 
  630.      rc = FALSE;
  631.     break;
  632.     }
  633.    }
  634.    memset(read_buffer,0,usr.lbsize);
  635.   }
  636.   fclose(scr); 
  637.  }
  638.  else Printf(GETSTR(8),filename); 
  639.  return rc;
  640. }
  641.  
  642.  
  643. UBYTE __regargs *skipeol(UBYTE *buffer)
  644. {
  645.  UBYTE *rc = buffer;
  646.  while((*rc == '\r') || (*rc == '\n'))rc++;
  647.  return rc;
  648. }
  649.  
  650. int __regargs SerRead(struct IOExtSer *ioreq, BYTE *data, ULONG length)
  651. {
  652.  ULONG sigs;
  653.  int rc;
  654.  ioreq->IOSer.io_Command = CMD_READ;
  655.  ioreq->IOSer.io_Data = (APTR) data;
  656.  ioreq->IOSer.io_Length = length;
  657.  SendIO( ioreq );
  658.  sigs = Wait( (1L<<TimerPort->mp_SigBit) | (1L<<serport->mp_SigBit) | SIGBREAKF_CTRL_C);
  659.  rc = check_sigs(sigs);
  660.  if(showlog)FPutC(showlog,*data);
  661.  return rc;
  662. }
  663.  
  664.  
  665. int __regargs SerWrite(struct IOExtSer *ioreq, BYTE *data, ULONG length)
  666. {
  667.  ULONG sigs;
  668.  ioreq->IOSer.io_Command = CMD_WRITE;
  669.  ioreq->IOSer.io_Data = (APTR) data;
  670.  ioreq->IOSer.io_Length = length;
  671.  SendIO( ioreq );
  672.  sigs = Wait((1L<<serport->mp_SigBit) | SIGBREAKF_CTRL_C);
  673.  if(sigs & SIGBREAKF_CTRL_C)
  674.  {
  675.   strcpy(bf,"(9) UCall :   ");
  676.   maketime(bf + 13);
  677.   strcat(bf,GETSTR(9));strcat(bf,"\n");
  678.   Printf(bf);
  679.   if(protfile)fputs(bf,protfile);
  680.   ser_cleanup(RETURN_ABBRUCH);
  681.  }
  682.  return TRUE;
  683. }
  684.  
  685.  
  686. int makecall()
  687. {
  688.  int rc = FALSE;
  689.  for ( script_node = script.lh_Head;script_node->ln_Succ;script_node = script_node->ln_Succ)
  690.  {
  691.   parsecomm(script_node->ln_Name);
  692.  }
  693.  return rc;
  694. }
  695.  
  696. void __regargs parsecomm(UBYTE *c)
  697. {
  698.  int i;
  699.  UBYTE *csource;
  700.  memset(ct,0,usr.lbsize);
  701.  for(i=0;cmds[i].text;i++)
  702.  {
  703.   if(!strnicmp(c,cmds[i].text,strlen(cmds[i].text)))
  704.   {
  705.    csource = c;
  706.    while(*csource > ' ')csource++;
  707.    csource = stpblk(csource);
  708.    makestring(ct,csource);
  709.    switch(cmds[i].n)
  710.    {
  711.     case C_TEXTFILE     : {
  712.                            LONG size;
  713.                            BPTR lock;
  714.                            BPTR file;
  715.                            UBYTE *p;
  716.                            struct FileInfoBlock __aligned fib;
  717.                            p = ct  + strlen(ct) - 1;
  718.                            while((*p == ' ') || (*p == '\n') || (*p == '\r')){*p = 0;--p;}
  719.                            if(lock = Lock(ct,ACCESS_READ))
  720.                            {
  721.                             Examine(lock,&fib);
  722.                             size = fib.fib_Size;
  723.                             UnLock(lock);
  724.                             if(file = Open(ct,MODE_OLDFILE))
  725.                             {
  726.                              if(sendfilebuffer = AllocVec(size + 2,MEMF_ANY | MEMF_CLEAR))
  727.                              {
  728.                               if(Read(file,sendfilebuffer,size))
  729.                               {
  730.                                SerWrite(serial_req_write,sendfilebuffer,(ULONG)size);
  731.                               }
  732.                               FreeVec(sendfilebuffer);
  733.                               sendfilebuffer = NULL;
  734.                              }
  735.                              Close(file);
  736.                             }
  737.                             else
  738.                             {
  739.                              Printf(GETSTR(10),ct);
  740.                              UnLock(lock);
  741.                             }
  742.                            } else Printf(GETSTR(11),ct);
  743.                           }
  744.                           break;
  745.     case C_SETENV       : if(*ct)
  746.                           {
  747.                            UBYTE *set,*var;
  748.                            set = strtok(ct,"=");
  749.                            if(set)
  750.                            {
  751.                             var = strtok(NULL,"=");
  752.                             if(var)
  753.                             {
  754.                              UBYTE *s1;
  755.                              for(s1 = set;*s1 && (s1 < var);s1++)
  756.                              if(*s1 == ' ')*s1 = 0;
  757.                              SetVar(set,var,-1,GVF_GLOBAL_ONLY);
  758.                             }
  759.                            }
  760.                           }
  761.                           break;
  762.     case C_GETENV       : if(*ct)
  763.                           {
  764.                            UBYTE *get,*var,*vr;
  765.                            struct var_node *vn;
  766.                            var = bf;
  767.                            *var = '$';*(var + 1) = 0;
  768.                            vr = strtok(ct,"=");
  769.                            if(vr)
  770.                            {
  771.                             strcat(var,vr);
  772.                             get = strtok(NULL,"=");
  773.                             if(get)
  774.                             {
  775.                              UBYTE *s1;
  776.                              for(s1 = var;*s1;s1++)if(*s1 == ' ')*s1 = 0;
  777.                              if(GetVar(get,file_buffer,usr.lbsize,0) > 0)
  778.                              {
  779.                               if(vn = (struct var_node *)FindName(&vars,var))
  780.                               {
  781.                                Remove(vn);
  782.                                if(vn->node.ln_Name)FreeVec(vn->node.ln_Name);
  783.                                if(vn->text)FreeVec(vn->text);
  784.                                FreeVec(vn);
  785.                               }
  786.                               if(vn = (struct var_node *)AllocVec(sizeof(struct var_node),MEMF_ANY | MEMF_CLEAR))
  787.                               {
  788.                                if(vn->node.ln_Name = AllocVec(strlen(var) + 10,MEMF_ANY | MEMF_CLEAR))
  789.                                {
  790.                                 if(vn->text = AllocVec(strlen(file_buffer) + 10, MEMF_ANY | MEMF_CLEAR))
  791.                                 {
  792.                                  strcpy(vn->node.ln_Name,var);
  793.                                  strcpy(vn->text,file_buffer);
  794.                                  AddHead(&vars,(struct Node *)vn);
  795.                                 }
  796.                                }
  797.                               }
  798.                              }
  799.                             }
  800.                            }
  801.                           }
  802.                           break;                      
  803.     case C_IFVAR        : {
  804.                            UBYTE *var,*value,*c;
  805.                            if(var = strtok(ct,","))
  806.                            {
  807.                             if(value = strtok(NULL,","))
  808.                             {
  809.                              value = stpblk(value);
  810.                              if(c = strtok(NULL,","))
  811.                              {
  812.                               c = stpblk(c);
  813.                               ParsePatternNoCase(value,pb,usr.lbsize);
  814.                               if(MatchPatternNoCase(pb,var))
  815.                               if(*c)multiple_if(c);
  816.                              }
  817.                             }
  818.                            }
  819.                           }                      
  820.                           break;
  821.     case C_DELAY        : if((*ct) && (isdigit(*ct)))
  822.                           {
  823.                            ULONG v = atol(ct);
  824.                            if(v > 1)
  825.                            {
  826.                             timerdelay(v);
  827.                            }
  828.                           }
  829.                           else timerdelay(global_repeat);
  830.                           break;
  831.     case C_LBSIZE       : if(isdigit(*ct))
  832.                           {
  833.                            ULONG size = atol(ct);
  834.                            if(size > 511)
  835.                            {
  836.                             freebuffers();
  837.                             usr.lbsize = size;
  838.                             if(!getbuffers())
  839.                             {
  840.                              Printf(GETSTR(12));
  841.                              ser_cleanup(RETURN_ABBRUCH);
  842.                             }
  843.                            }
  844.                           }
  845.                           break;
  846.     case C_RESETLINE    : readbytes = 0;
  847.                           serial_req_cmd->IOSer.io_Command = CMD_CLEAR;  
  848.                           DoIO( serial_req_cmd );
  849.                           break;
  850.     case C_SET          : {
  851.                            struct var_node *v;
  852.                            UBYTE *c;
  853.                            c = strtok(ct,"=");
  854.                            if(c)
  855.                            {
  856.                             c = strtok(NULL,"=");
  857.                             if(c)
  858.                             {
  859.                              if(v = (struct var_node *)AllocVec(sizeof(struct var_node),MEMF_ANY | MEMF_CLEAR))
  860.                              {
  861.                               if(v->node.ln_Name = AllocVec(strlen(ct) + 10,MEMF_ANY | MEMF_CLEAR))
  862.                               {
  863.                                if(v->text = AllocVec(strlen(c) + 10,MEMF_ANY | MEMF_CLEAR))
  864.                                {
  865.                                 UBYTE *s = ct;
  866.                                 UBYTE *d = v->node.ln_Name + 1;
  867.                                 *(v->node.ln_Name) = '$';
  868.                                 while(1)
  869.                                 {
  870.                                  *d++ = *s++;
  871.                                  if((!(*s)) || (s == c) || (*s == ' ') )break;
  872.                                 }
  873.                                 strcpy(v->text,c);
  874.                                 AddHead(&vars,(struct Node *)v);
  875.                                }
  876.                               }
  877.                               else
  878.                               {
  879.                                FreeVec(v);
  880.                               }
  881.                              }
  882.                             }
  883.                            }
  884.                           }
  885.                           break;
  886.     case C_PROTMSG      : if(protfile)fputs(ct,protfile);
  887.                           break;
  888.     case C_PROTOCOL     : {
  889.                            UBYTE *name;
  890.                            if(protfile)
  891.                            {
  892.                             fclose(protfile);
  893.                            }
  894.                            if(*ct)name = ct;
  895.                            else  name = "ucall.protocol";
  896.                            protfile = fopen(name,"a");
  897.                           }
  898.                           break;
  899.     case C_SETFLAG      : {
  900.                            ULONG n;
  901.                            if(isdigit(*ct))
  902.                            {
  903.                             n = atol(ct);
  904.                             if((n > 7) && (n < 32))
  905.                             {
  906.                              flags |= (1 << n);
  907.                             }
  908.                             else Printf(GETSTR(13));
  909.                            }
  910.                           }
  911.                           break;
  912.     case C_CLEARFLAG     : {
  913.                            ULONG n;
  914.                            if(isdigit(*ct))
  915.                            {
  916.                             n = atol(ct);
  917.                             if((n >= 0) && (n < 32))
  918.                             {
  919.                              if(flags & (1 << n))flags ^= (1 << n);
  920.                             }
  921.                            }
  922.                           }
  923.                           break;  
  924.     case C_IFFLAG       : {
  925.                            ULONG n;
  926.                            if(isdigit(*ct))
  927.                            {
  928.                             n = atol(ct);
  929.                             if((n >= 0) && (n < 32))
  930.                             {
  931.                              if(flags & (1 << n))
  932.                              {
  933.                               UBYTE *next;
  934.                               for(next = ct;((*next) &&(*next != ' '));next++);
  935.                               next = stpblk(next);
  936.                               if(*next)multiple_if(next);
  937.                              }
  938.                             }
  939.                            }
  940.                           }
  941.                           break;                     
  942.     case C_TIMELABEL    : timeout_label = script_node;
  943.                           break;
  944.     case C_GOSUB        : {
  945.                            struct Node *node;
  946.                            struct r_node *ret;
  947.                            strcpy(bf,LABELINTRO);
  948.                            strncat(bf,ct,usr.lbsize);
  949.                            if(node = FindName(&script,bf))
  950.                            {
  951.                             if(ret = (struct r_node *)AllocVec(sizeof(struct r_node),MEMF_ANY | MEMF_CLEAR))
  952.                             {
  953.                              ret->ziel = script_node;
  954.                              AddHead(&return_stack,(struct Node *)ret);
  955.                              script_node = node;
  956.                             }
  957.                            }
  958.                            else Printf(GETSTR(14),bf);
  959.                           } 
  960.                           break;
  961.     case C_RETURN       : {
  962.                            struct r_node *node;
  963.                            if(node = (struct r_node *)RemHead(&return_stack))
  964.                            {
  965.                             script_node = node->ziel;
  966.                             FreeVec(node);
  967.                            }
  968.                            else Printf(GETSTR(15));
  969.                           }
  970.                           break;
  971.     case C_IF           : {
  972.                            UBYTE *next;
  973.                            for(next = ct;((*next) &&(*next != ' '));next++);
  974.                            {
  975.                             *next = 0;
  976.                             ParsePatternNoCase(ct,pb,usr.lbsize);
  977.                             next++;
  978.                             if(MatchPatternNoCase(pb,last_line))
  979.                             {
  980.                              if(*next)multiple_if(next);
  981.                             }
  982.                            }
  983.                           }
  984.                           break;
  985.     case C_LABEL        : break;
  986.     case C_GOTO         : {
  987.                            struct Node *node;
  988.                            strcpy(bf,LABELINTRO);
  989.                            strncat(bf,ct,usr.lbsize);
  990.                            if(node = FindName(&script,bf))script_node = node;
  991.                            else Printf(GETSTR(16),bf);
  992.                           } 
  993.                           break;
  994.     case C_END          : ser_cleanup(0);
  995.                           break;
  996.     case C_REPEAT       : if(isdigit(*ct))global_repeat = atol(ct);
  997.                           break;
  998.     case C_TIMEOUT      : if(isdigit(*ct))global_timeout = atol(ct);
  999.                           break;
  1000.     case C_SHLOG        : {
  1001.                            if(*ct)
  1002.                            {
  1003.                             if(!showlog)
  1004.                             {
  1005.                              showlog = Open(ct,MODE_NEWFILE);
  1006.                             }
  1007.                            }
  1008.                            else
  1009.                            {
  1010.                             if(!showlog)
  1011.                             {
  1012.                              showlog=Open("con:0/0/640/480/UCall: Login",MODE_NEWFILE);
  1013.                             }
  1014.                            }
  1015.                           }
  1016.                           break;
  1017.     case C_WCONNECT     : {
  1018.                            UBYTE *eol;
  1019.                            while(1)
  1020.                            {
  1021.                             Printf(GETSTR(17),ct);
  1022.                             SerWrite(serial_req_write,ct,-1);
  1023.                             sprintf(bf,"%s,%s,%s,%s",usr.connect,usr.busy,usr.nocarrier,usr.nodialtone);
  1024.                             waitstring(bf);
  1025.                             eol = read_buffer;
  1026.                             if(!strnicmp(eol,usr.connect,strlen(usr.connect)))
  1027.                             {
  1028.                              Printf("UCall : %s\n",eol);
  1029.                              break;
  1030.                             }
  1031.                             else
  1032.                             if(!strnicmp(eol,usr.busy,strlen(usr.busy)))
  1033.                             {
  1034.                              Printf(GETSTR(18));
  1035.                              timerdelay(global_repeat);
  1036.                             }
  1037.                             else
  1038.                             if(!strnicmp(eol,usr.nocarrier,strlen(usr.nocarrier)))
  1039.                             {
  1040.                              Printf(GETSTR(19));
  1041.                              timerdelay(global_repeat);
  1042.                             }
  1043.                             else
  1044.                             if(!strnicmp(eol,usr.nodialtone,strlen(usr.nodialtone)))
  1045.                             {
  1046.                              Printf(GETSTR(20));
  1047.                              timerdelay(global_repeat);
  1048.                             }
  1049.                            }
  1050.                           }
  1051.                           break; 
  1052.                           
  1053.     case C_WAIT       : timeout_start(global_timeout);
  1054.                         waitstring(ct);
  1055.                         timeout_end();
  1056.                         break;
  1057.     case C_SEND       : SerWrite(serial_req_write,ct,-1);
  1058.                         break;
  1059.     case C_CRLF       : SerWrite(serial_req_write,"\r\n",-1);
  1060.                         break;
  1061.     case C_MSG        : fputs(ct,stdout);fflush(stdout);
  1062.                         break;
  1063.     case C_COMMENT    : break;
  1064.     case C_SENDFILE   : {
  1065.                          timeout_end();
  1066.                          TransferSetupShared(serial_req_read,serial_req_write,usr.xprlib);
  1067.                          SetOptions(usr.xpropt);
  1068.                          strcpy(read_buffer,ct);
  1069.                          if(!SendFile(read_buffer,2,NULL))flags |= (1<<FLAG_UPLOAD);
  1070.                          strcpy(file_buffer,read_buffer);
  1071.                         }
  1072.                         /* File senden ! */
  1073.                         break;
  1074.     case C_GETFILE    : {
  1075.                          timeout_end();
  1076.                          TransferSetupShared(serial_req_read,serial_req_write,usr.xprlib);
  1077.                          SetOptions(usr.xpropt);
  1078.                          strcpy(read_buffer,ct);
  1079.                          if(!ReceiveFile(read_buffer,2,NULL))flags |= (1<<FLAG_DOWNLOAD);
  1080.                          strcpy(file_buffer,read_buffer);
  1081.                         }
  1082.                         /* file holen */
  1083.                         break;
  1084.     case C_SYSTEM     : System(ct,TAG_DONE);
  1085.                         break;
  1086.     case C_WORKDIR    : {
  1087.                          BPTR lock,cd;
  1088.                          if(lock = Lock(ct,SHARED_LOCK))
  1089.                          {
  1090.                           cd = CurrentDir(lock);
  1091.                           UnLock(cd);
  1092.                          }
  1093.                         }
  1094.                         break;
  1095.     default           : break;                   
  1096.    }
  1097.    break;
  1098.   }
  1099.  }
  1100. }
  1101.  
  1102.  
  1103. void __regargs waitstring(UBYTE *string)
  1104. {
  1105.  UBYTE i = 0;
  1106.  UBYTE j;
  1107.  UBYTE *eol,*tmp;
  1108.  readbytes = 0; 
  1109.  memset(read_buffer,0,usr.lbsize);
  1110.  tmp = strtok(string,",");
  1111.  while(tmp)
  1112.  {
  1113.   *(chr_buffer + i) = *(tmp + strlen(tmp) -1);
  1114.   ParsePatternNoCase(tmp,pattern_buffer[i],BUFFER_SIZE_PATTERN);
  1115.   tmp = strtok(NULL,",");
  1116.   i++;
  1117.   if(i >= MAX_BREAKCHARS)break;
  1118.  }
  1119.  while(1)
  1120.  {
  1121.   int r;
  1122.   r = read_line(read_buffer,chr_buffer,i);
  1123.   if(!r)return;
  1124.   else 
  1125.   if (r == 3);
  1126.   {
  1127.    eol = skipeol(read_buffer);
  1128.    for(j = 0 ; j < i ; j++)
  1129.    {
  1130.     if(MatchPatternNoCase(pattern_buffer[j],eol))
  1131.     {
  1132.      strcpy(last_line,eol);
  1133.      for(j = 0 ; j < i ; j++)memset(pattern_buffer[j],0,BUFFER_SIZE_PATTERN);
  1134.      return;
  1135.     }
  1136.    }                           
  1137.   }
  1138.  } 
  1139. }
  1140.  
  1141. void __regargs makestring(UBYTE *dest,UBYTE *source)
  1142. {
  1143.  UBYTE *s,*d;
  1144.  long n;
  1145.  d = dest;
  1146.  s = source;  
  1147.  while(*d = *s)
  1148.  {
  1149.   if(*s == '\\')
  1150.   {
  1151.    s++;
  1152.    if(*s == 'n'){*d = '\n';d++;s++;}
  1153.    if(*s == 'r'){*d = '\r';d++;s++;}
  1154.    if((*s == 'x') || (*s == 'X'))
  1155.    {
  1156.     s++;
  1157.     s +=  stch_l(s,&n);--s;
  1158.     *d = (UBYTE)n;
  1159.    }
  1160.   }
  1161.   if (*s == '$')
  1162.   {
  1163.    ULONG i;
  1164.    struct Node *n;
  1165.    struct var_node *found = NULL;
  1166.    for(n = vars.lh_Head;n->ln_Succ;n = n->ln_Succ)
  1167.    {
  1168.     if(!strnicmp(s,n->ln_Name,strlen(n->ln_Name)))
  1169.     {
  1170.      found = (struct var_node *)n;
  1171.      break;
  1172.     }
  1173.    }
  1174.    if(!found)
  1175.    for(i=0;usr_vars[i].text;i++)
  1176.    {
  1177.     if(!strnicmp(s,usr_vars[i].text,strlen(usr_vars[i].text)))
  1178.     {
  1179.      var_x(&d,&s,i);
  1180.      break;
  1181.     }
  1182.    }
  1183.    else
  1184.    {
  1185.     strncpy(d,found->text,usr.lbsize);
  1186.     d += strlen(found->text) - 1 ;
  1187.     s += strlen(found->node.ln_Name) - 1;
  1188.    }
  1189.   }
  1190.   d++;s++;
  1191.  }
  1192. }
  1193.  
  1194. void timeout_end()
  1195. {
  1196.  if(!CheckIO(tr))
  1197.  {
  1198.   AbortIO(tr);
  1199.   WaitIO(tr);
  1200.  }
  1201. }
  1202.  
  1203. void __regargs timeout_start(ULONG sec)
  1204. {
  1205.  timeout_end();
  1206.  tr->tr_node.io_Command = TR_ADDREQUEST;
  1207.  tr->tr_time.tv_secs = sec;
  1208.  tr->tr_time.tv_micro = 0;
  1209.  SendIO(tr);   
  1210. }
  1211.  
  1212. void __regargs timerdelay(ULONG sec)
  1213. {
  1214.  ULONG sigs;
  1215.  int i;
  1216.  if(!CheckIO(tr))
  1217.  {
  1218.   AbortIO(tr);
  1219.   WaitIO(tr);
  1220.  }
  1221.  for(i = sec;i > 0;i--)
  1222.  {
  1223.   tr->tr_node.io_Command = TR_ADDREQUEST;
  1224.   tr->tr_time.tv_secs = 1;
  1225.   tr->tr_time.tv_micro = 0;
  1226.   SendIO(tr);
  1227.   {Printf(GETSTR(21),i);fflush(stdout);}
  1228.   sigs = Wait( (1L<<TimerPort->mp_SigBit) | SIGBREAKF_CTRL_C);
  1229.   if(sigs & SIGBREAKF_CTRL_C)
  1230.   {
  1231.    strcpy(bf,"(9) UCall :   ");
  1232.    maketime(bf + 13);
  1233.    strcat(bf,GETSTR(9));strcat(bf,"\n");
  1234.    Printf(bf);
  1235.    if(protfile)fputs(bf,protfile);
  1236.    ser_cleanup(RETURN_ABBRUCH); 
  1237.   }
  1238.   if(sigs & (1L<<TimerPort->mp_SigBit))GetMsg(TimerPort);
  1239.  }
  1240. }
  1241.  
  1242. void var_x(UBYTE **d,UBYTE **s,ULONG what)
  1243. {
  1244.  UBYTE *s1;
  1245.  ULONG w = usr_vars[what].n;
  1246.  switch(w)
  1247.  {
  1248.   case V_OK            : s1 = usr.ok;           break;
  1249.   case V_ERROR         : s1 = usr.error;        break;
  1250.   case V_CONNECT       : s1 = usr.connect;      break;
  1251.   case V_NOCARRIER     : s1 = usr.nocarrier;    break;
  1252.   case V_NODIALTONE    : s1 = usr.nodialtone;   break;
  1253.   case V_DEVICE        : s1 = usr.device;       break;
  1254.   case V_DELAYED       : s1 = usr.delayed;      break;
  1255.   case V_XPRLIB        : s1 = usr.xprlib;       break;
  1256.   case V_XPROPTS       : s1 = usr.xpropt;       break;
  1257.   case V_BUSY          : s1 = usr.busy;         break;
  1258.   case V_LBSIZE        : sprintf(bf,"%ld",usr.lbsize); s1 = bf; break;
  1259.   case V_BUFFER        : sprintf(bf,"%ld",usr.bufsize); s1 = bf; break;
  1260.   case V_BAUD          : sprintf(bf,"%ld",usr.baud); s1 = bf; break;
  1261.   case V_UNIT          : sprintf(bf,"%ld",usr.unit); s1 = bf; break;
  1262.   case V_DATABITS      : sprintf(bf,"%d",usr.data); s1 = bf; break;
  1263.   case V_STOPBITS      : sprintf(bf,"%d",usr.stop); s1 = bf; break;
  1264.   case V_PARITY        : sprintf(bf,"%s",(usr.parity == 0) ? "NONE" : (usr.parity == 1) ? "EVEN" : "ODD"); s1 = bf; break;  
  1265.   case V_HANDSHAKE     : sprintf(bf,"%s",(usr.handshake == 0) ? "RTS/CTS" : "XON/XOFF");s1 = bf; break;
  1266.   case V_LINE          : s1 = read_buffer; break;
  1267.   case V_CONFIG        : s1 = usr.cfgfile; break;
  1268.   case V_SCRIPT        : s1 = usr.script;  break;
  1269.   case V_FILENAME      : s1 = file_buffer;
  1270.                          break;
  1271.   case V_FILESIZE      : s1 = bf;
  1272.                          {
  1273.                           BPTR lock;
  1274.                           struct FileInfoBlock __aligned fib;
  1275.                           if(lock = Lock(file_buffer,ACCESS_READ))
  1276.                           {
  1277.                            Examine(lock,&fib);
  1278.                            sprintf(bf,"%ld",fib.fib_Size);
  1279.                            UnLock(lock);
  1280.                           }
  1281.                           else strcpy(bf,GETSTR(22));
  1282.                          }
  1283.                          break;
  1284.   case V_FILEINFO      : s1 = bf;
  1285.                          {
  1286.                           BPTR lock;
  1287.                           struct FileInfoBlock __aligned fib;
  1288.                           if(lock = Lock(file_buffer,ACCESS_READ))
  1289.                           {
  1290.                            Examine(lock,&fib);
  1291.                            sprintf(bf,"%s %ld Bytes",fib.fib_FileName,fib.fib_Size);
  1292.                            UnLock(lock);
  1293.                           }
  1294.                           else strcpy(bf,GETSTR(22));
  1295.                          }
  1296.                          break;
  1297.   case V_TIME          : {
  1298.                           maketime(bf);
  1299.                           s1 = bf;
  1300.                          }
  1301.                          break;
  1302.   case V_DATE          : {
  1303.                           struct DateStamp dst;
  1304.                           GetSysTime(&datum);
  1305.                           Amiga2Date(datum.tv_secs,&cd);
  1306.                           if(LocaleBase)
  1307.                           {
  1308.                            bfp = bf;
  1309.                            DateStamp(&dst); 
  1310.                            FormatDate(loc,loc->loc_DateFormat,&dst,&localedatehook);
  1311.                           }
  1312.                           else
  1313.                           sprintf(bf,"%s %d-%s-%d",
  1314.                                   tage[cd.wday],
  1315.                                   cd.mday,
  1316.                                   monate[cd.month-1],
  1317.                                   cd.year);
  1318.  
  1319.                           s1 = bf;
  1320.                          }
  1321.                          break;
  1322.   default              : return;                    
  1323.  }
  1324.  while(*(*d)++ = *s1++);(*d) -= 2;(*s) += strlen(usr_vars[what].text) - 1;
  1325. }
  1326.  
  1327. int getbuffers()
  1328. {
  1329.  if(read_buffer = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1330.  {
  1331.   if(file_buffer = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1332.   {
  1333.    if(last_line  = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1334.    {
  1335.     if(ct  = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1336.     {
  1337.      if(bf  = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1338.      {
  1339.       if(pb = (UBYTE *)AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1340.       {
  1341.        return TRUE;   
  1342.       }
  1343.      }
  1344.     } 
  1345.    } 
  1346.   }
  1347.  }
  1348.  Printf(GETSTR(23));
  1349.  return FALSE;
  1350. }
  1351.  
  1352. void freebuffers()
  1353. {
  1354.  if(last_line){FreeVec(last_line);last_line = NULL;}
  1355.  if(read_buffer){FreeVec(read_buffer);read_buffer = NULL;}
  1356.  if(ct){FreeVec(ct);ct = NULL;}
  1357.  if(bf){FreeVec(bf);bf = NULL;}
  1358.  if(file_buffer){FreeVec(file_buffer);file_buffer = NULL;}
  1359.  if(pb){FreeVec(pb);pb = NULL;}
  1360. }
  1361.  
  1362. void multiple_if(UBYTE *line)
  1363. {
  1364.  struct Node *node;
  1365.  UBYTE *np;
  1366.  if(node = (struct Node *)AllocVec(sizeof(struct Node),MEMF_ANY | MEMF_CLEAR))
  1367.  { 
  1368.   if(node->ln_Name = AllocVec(usr.lbsize,MEMF_ANY | MEMF_CLEAR))
  1369.   {
  1370.    AddHead(&extramem,node);
  1371.    CopyMem(line,node->ln_Name,usr.lbsize);
  1372.    np = strtok(node->ln_Name,",");
  1373.    while(np)
  1374.    {
  1375.     parsecomm(np);
  1376.     np = strtok(NULL,",");
  1377.    }
  1378.    if(node = RemHead(&extramem))
  1379.    {
  1380.     if(node->ln_Name)FreeVec(node->ln_Name);
  1381.     FreeVec(node);
  1382.    }
  1383.   }
  1384.  }
  1385. }
  1386.  
  1387. int check_sigs(ULONG sigs)
  1388. {
  1389.  if(sigs & SIGBREAKF_CTRL_C)
  1390.  {
  1391.   strcpy(bf,"(9) UCall :    ");
  1392.   maketime(bf + 13);
  1393.   strcat(bf,GETSTR(9));strcat(bf,"\n");
  1394.   Printf(bf);
  1395.   if(protfile)fputs(bf,protfile);
  1396.   ser_cleanup(RETURN_ABBRUCH);
  1397.  }
  1398.  if(sigs & (1L<<TimerPort->mp_SigBit))
  1399.  {
  1400.   if(GetMsg(TimerPort))
  1401.   {
  1402.    if(timeout_label)
  1403.    {
  1404.     ser_cleanup(CLEANUP_RESTART);
  1405.     script_node = timeout_label;
  1406.     flags |= (1<<FLAG_TIMEOUT);
  1407.     return FALSE;
  1408.    }
  1409.    else
  1410.    {
  1411.     strcpy(bf,"(24) UCall :   ");
  1412.     maketime(bf + 13);
  1413.     strcat(bf,GETSTR(24));strcat(bf,"\n");
  1414.     Printf(bf);
  1415.     if(protfile)fputs(bf,protfile);
  1416.     ser_cleanup(RETURN_ABBRUCH);
  1417.    }
  1418.   }
  1419.  }
  1420.  return TRUE;
  1421. }
  1422.  
  1423. void    getlocale()
  1424. {
  1425.  if(LocaleBase = OpenLibrary("locale.library",38))
  1426.  {
  1427.   loc = OpenLocale(NULL);
  1428.   cat = OpenCatalog(loc,"ucall.catalog",OC_BuiltInLanguage,"deutsch",OC_Version,1,TAG_DONE);
  1429.  }
  1430. }
  1431.  
  1432. void releaselocale()
  1433. {
  1434.  if(cat)
  1435.  {
  1436.   CloseCatalog(cat);
  1437.   cat = NULL;
  1438.  }
  1439.  if(loc)
  1440.  {
  1441.   CloseLocale(loc);
  1442.   loc = NULL;
  1443.  }
  1444.  if(LocaleBase){CloseLibrary(LocaleBase);LocaleBase = NULL;}
  1445. }
  1446.  
  1447. void __asm __saveds locale_date_func(register __a1 UBYTE chr)
  1448. {
  1449.  *bfp++ = chr;
  1450. }
  1451.  
  1452. void maketime(UBYTE *to)
  1453. {
  1454.  struct DateStamp dst;
  1455.  GetSysTime(&datum);
  1456.  Amiga2Date(datum.tv_secs,&cd);
  1457.  if(LocaleBase)
  1458.  {
  1459.   bfp = to;
  1460.   DateStamp(&dst); 
  1461.   FormatDate(loc,loc->loc_TimeFormat,&dst,&localedatehook);
  1462.  }
  1463.  else
  1464.  sprintf(to,"(%02d:%02d:%02d) ",
  1465.              cd.hour,
  1466.              cd.min,
  1467.              cd.sec);
  1468. }
  1469.